procedure UpdateTransformer(var model: TTransformer; learningRate: Double);
var
  i, j: Integer;
begin
  WriteLn('UpdateTransformer: начат');
  WriteLn('  learningRate: ', learningRate:0:6);

  try
    // 1. Обновление эмбеддингов
    WriteLn('  Обновление эмбеддингов...');
    for i := 0 to High(model.Embedding) do 
    begin
      for j := 0 to High(model.Embedding[i]) do 
      begin
        // ✅ ЗАЩИТА: Проверяем границы массивов
        if (i < Length(model.Embedding_Grad)) and 
           (j < Length(model.Embedding_Grad[i])) then 
        begin
          model.Embedding[i][j] := model.Embedding[i][j] - learningRate * model.Embedding_Grad[i][j];
        end;
      end;
    end;

    // 2. Обновление всех слоев
    WriteLn('  Обновление слоев...');
    for i := 0 to High(model.Layers) do 
    begin
      WriteLn('    Слой ', i, ':');

      // Attention weights
      WriteLn('      Attention heads...');
      for j := 0 to High(model.Layers[i].SelfAttention.Heads) do 
      begin
        WriteLn('        Голова ', j, ':');
        
        // ✅ ЗАЩИТА: Добавляем проверки для каждой матрицы
        // Wq
        if (Length(model.Layers[i].SelfAttention.Heads[j].Wq) > 0) and
           (Length(model.Layers[i].SelfAttention.Heads[j].dWq) > 0) and
           (Length(model.Layers[i].SelfAttention.Heads[j].Wq) = Length(model.Layers[i].SelfAttention.Heads[j].dWq)) and
           (Length(model.Layers[i].SelfAttention.Heads[j].Wq[0]) = Length(model.Layers[i].SelfAttention.Heads[j].dWq[0])) then
        begin
          UpdateMatrixWithAdam(model.Layers[i].SelfAttention.Heads[j].Wq, 
                             model.Layers[i].SelfAttention.Heads[j].dWq, 
                             model.Layers[i].SelfAttention.Heads[j].Wq_AdamState, 
                             learningRate);
        end
        else
        begin
          WriteLn('        Предупреждение: Пропускаем Wq - несовпадение размеров');
        end;

        // Аналогично для Wk, Wv, Wo...
        // Wk
        if (Length(model.Layers[i].SelfAttention.Heads[j].Wk) > 0) and
           (Length(model.Layers[i].SelfAttention.Heads[j].dWk) > 0) and
           (Length(model.Layers[i].SelfAttention.Heads[j].Wk) = Length(model.Layers[i].SelfAttention.Heads[j].dWk)) and
           (Length(model.Layers[i].SelfAttention.Heads[j].Wk[0]) = Length(model.Layers[i].SelfAttention.Heads[j].dWk[0])) then
        begin
          UpdateMatrixWithAdam(model.Layers[i].SelfAttention.Heads[j].Wk, 
                             model.Layers[i].SelfAttention.Heads[j].dWk, 
                             model.Layers[i].SelfAttention.Heads[j].Wk_AdamState, 
                             learningRate);
        end;

        // Wv
        if (Length(model.Layers[i].SelfAttention.Heads[j].Wv) > 0) and
           (Length(model.Layers[i].SelfAttention.Heads[j].dWv) > 0) and
           (Length(model.Layers[i].SelfAttention.Heads[j].Wv) = Length(model.Layers[i].SelfAttention.Heads[j].dWv)) and
           (Length(model.Layers[i].SelfAttention.Heads[j].Wv[0]) = Length(model.Layers[i].SelfAttention.Heads[j].dWv[0])) then
        begin
          UpdateMatrixWithAdam(model.Layers[i].SelfAttention.Heads[j].Wv, 
                             model.Layers[i].SelfAttention.Heads[j].dWv, 
                             model.Layers[i].SelfAttention.Heads[j].Wv_AdamState, 
                             learningRate);
        end;

        // Wo
        if (Length(model.Layers[i].SelfAttention.Heads[j].Wo) > 0) and
           (Length(model.Layers[i].SelfAttention.Heads[j].dWo) > 0) and
           (Length(model.Layers[i].SelfAttention.Heads[j].Wo) = Length(model.Layers[i].SelfAttention.Heads[j].dWo)) and
           (Length(model.Layers[i].SelfAttention.Heads[j].Wo[0]) = Length(model.Layers[i].SelfAttention.Heads[j].dWo[0])) then
        begin
          UpdateMatrixWithAdam(model.Layers[i].SelfAttention.Heads[j].Wo, 
                             model.Layers[i].SelfAttention.Heads[j].dWo, 
                             model.Layers[i].SelfAttention.Heads[j].Wo_AdamState, 
                             learningRate);
        end;
      end;

      // FFN weights с защитой
      WriteLn('      FFN weights...');
      if (Length(model.Layers[i].FFN_weights1) > 0) and
         (Length(model.Layers[i].FFN1_Grad) > 0) and
         (Length(model.Layers[i].FFN_weights1) = Length(model.Layers[i].FFN1_Grad)) and
         (Length(model.Layers[i].FFN_weights1[0]) = Length(model.Layers[i].FFN1_Grad[0])) then
      begin
        UpdateMatrixWithAdam(model.Layers[i].FFN_weights1, 
                           model.Layers[i].FFN1_Grad, 
                           model.Layers[i].FFN1_AdamState, 
                           learningRate);
      end
      else
      begin
        WriteLn('      Предупреждение: Пропускаем FFN1 - несовпадение размеров');
      end;

      if (Length(model.Layers[i].FFN_weights2) > 0) and
         (Length(model.Layers[i].FFN2_Grad) > 0) and
         (Length(model.Layers[i].FFN_weights2) = Length(model.Layers[i].FFN2_Grad)) and
         (Length(model.Layers[i].FFN_weights2[0]) = Length(model.Layers[i].FFN2_Grad[0])) then
      begin
        UpdateMatrixWithAdam(model.Layers[i].FFN_weights2, 
                           model.Layers[i].FFN2_Grad, 
                           model.Layers[i].FFN2_AdamState, 
                           learningRate);
      end;

      // LayerNorm parameters
      WriteLn('      LayerNorm parameters...');
      if (Length(model.Layers[i].Norm1_Gamma) > 0) and
         (Length(model.Layers[i].Norm1_Gamma_Grad) > 0) and
         (Length(model.Layers[i].Norm1_Gamma) = Length(model.Layers[i].Norm1_Gamma_Grad)) then
      begin
        UpdateVectorAdam(model.Layers[i].Norm1_Gamma, 
                       model.Layers[i].Norm1_Gamma_Grad, 
                       model.Layers[i].Norm1_Gamma_AdamState, 
                       learningRate);
      end;

      // Аналогично для остальных LayerNorm параметров...
      if (Length(model.Layers[i].Norm1_Beta) > 0) and
         (Length(model.Layers[i].Norm1_Beta_Grad) > 0) and
         (Length(model.Layers[i].Norm1_Beta) = Length(model.Layers[i].Norm1_Beta_Grad)) then
      begin
        UpdateVectorAdam(model.Layers[i].Norm1_Beta, 
                       model.Layers[i].Norm1_Beta_Grad, 
                       model.Layers[i].Norm1_Beta_AdamState, 
                       learningRate);
      end;

      if (Length(model.Layers[i].Norm2_Gamma) > 0) and
         (Length(model.Layers[i].Norm2_Gamma_Grad) > 0) and
         (Length(model.Layers[i].Norm2_Gamma) = Length(model.Layers[i].Norm2_Gamma_Grad)) then
      begin
        UpdateVectorAdam(model.Layers[i].Norm2_Gamma, 
                       model.Layers[i].Norm2_Gamma_Grad, 
                       model.Layers[i].Norm2_Gamma_AdamState, 
                       learningRate);
      end;

      if (Length(model.Layers[i].Norm2_Beta) > 0) and
         (Length(model.Layers[i].Norm2_Beta_Grad) > 0) and
         (Length(model.Layers[i].Norm2_Beta) = Length(model.Layers[i].Norm2_Beta_Grad)) then
      begin
        UpdateVectorAdam(model.Layers[i].Norm2_Beta, 
                       model.Layers[i].Norm2_Beta_Grad, 
                       model.Layers[i].Norm2_Beta_AdamState, 
                       learningRate);
      end;
    end;

    // 3. Применяем weight decay
    if model.Config.WeightDecay > 0 then 
    begin
      WriteLn('  Применение weight decay...');
      ApplyWeightDecay(model, learningRate);
    end;

    // 4. Сброс градиентов
    WriteLn('  Сброс градиентов...');
    ResetGradients(model);

    WriteLn('UpdateTransformer: завершен');

  except
    on E: Exception do 
    begin
      WriteLn('ОШИБКА в UpdateTransformer: ', E.Message);
      WriteLn('  Тип ошибки: ', E.ClassName);
      WriteLn('Продолжаем без обновления весов');
    end;
  end;
end;

// В ForwardAttentionOptimized исправим выходную проекцию:
// Заменяем этот блок:
// Output := MatrixMultiply(concatOutput, Attention.Heads[0].Wo);

// На этот:
if (Length(concatOutput) > 0) and (Length(Attention.Heads[0].Wo) > 0) and
   (Length(concatOutput[0]) = Length(Attention.Heads[0].Wo)) then 
begin
  Output := MatrixMultiply(concatOutput, Attention.Heads[0].Wo);
  WriteLn('        Output после проекции: ', Length(Output), 'x', Length(Output[0]));
end 
else 
begin
  WriteLn('        Предупреждение: Несовпадение размеров для выходной проекции');
  WriteLn('          concatOutput: ', Length(concatOutput), 'x', 
          IfThen(Length(concatOutput) > 0, IntToStr(Length(concatOutput[0])), '0'));
  WriteLn('          Wo: ', Length(Attention.Heads[0].Wo), 'x', 
          IfThen(Length(Attention.Heads[0].Wo) > 0, IntToStr(Length(Attention.Heads[0].Wo[0])), '0'));
  
  // Fallback: используем сумму выходов голов
  Output := CreateZeroMatrix(Length(concatOutput), Length(concatOutput[0]));
  for i := 0 to High(concatOutput) do
    for j := 0 to High(concatOutput[0]) do
      Output[i][j] := concatOutput[i][j];
end;

procedure SimpleBackwardLayer(var Layer: TTransformerLayer; const gradOutput: TDoubleMatrix; out gradInput: TDoubleMatrix);
var
  i, j: Integer;
  simpleGradW1, simpleGradW2: TDoubleMatrix;
  sum: Double;
begin
  WriteLn('    SimpleBackwardLayer: начат');
  WriteLn('      gradOutput: ', Length(gradOutput), 'x', 
          IfThen(Length(gradOutput) > 0, IntToStr(Length(gradOutput[0])), '0'));

  try
    // ✅ ИНИЦИАЛИЗИРУЕМ ГРАДИЕНТЫ ЕСЛИ ОНИ ПУСТЫЕ
    if Length(Layer.FFN_weights1_Grad) = 0 then
    begin
      WriteLn('      Инициализируем FFN_weights1_Grad...');
      SetLength(Layer.FFN_weights1_Grad, Length(Layer.FFN_weights1), Length(Layer.FFN_weights1[0]));
      FillMatrix(Layer.FFN_weights1_Grad, 0.0);
    end;

    if Length(Layer.FFN_weights2_Grad) = 0 then
    begin
      WriteLn('      Инициализируем FFN_weights2_Grad...');
      SetLength(Layer.FFN_weights2_Grad, Length(Layer.FFN_weights2), Length(Layer.FFN_weights2[0]));
      FillMatrix(Layer.FFN_weights2_Grad, 0.0);
    end;

    // Остальной код остается без изменений...
    // [существующий код SimpleBackwardLayer]
    
  except
    on E: Exception do
    begin
      WriteLn('ОШИБКА в SimpleBackwardLayer: ', E.Message);
      gradInput := CopyMatrix(gradOutput);
    end;
  end;
end;

function ValidateModelStructure(const Model: TTransformer): Boolean;
var
  i, j: Integer;
begin
  WriteLn('=== ПРОВЕРКА СТРУКТУРЫ МОДЕЛИ ===');
  Result := True;
  
  // Проверка embedding
  if (Length(Model.Embedding) = 0) or (Length(Model.Embedding[0]) = 0) then
  begin
    WriteLn('ОШИБКА: Embedding матрица пустая');
    Result := False;
  end;

  // Проверка слоев
  if Length(Model.Layers) <> Model.Config.NumLayers then
  begin
    WriteLn('ОШИБКА: Количество слоев не совпадает с конфигурацией');
    Result := False;
  end;

  for i := 0 to High(Model.Layers) do
  begin
    // Проверка FFN весов
    if (Length(Model.Layers[i].FFN_weights1) = 0) or 
       (Length(Model.Layers[i].FFN_weights1[0]) = 0) then
    begin
      WriteLn('ОШИБКА: FFN_weights1 слоя ', i, ' пустые');
      Result := False;
    end;

    if (Length(Model.Layers[i].FFN_weights2) = 0) or 
       (Length(Model.Layers[i].FFN_weights2[0]) = 0) then
    begin
      WriteLn('ОШИБКА: FFN_weights2 слоя ', i, ' пустые');
      Result := False;
    end;

    // Проверка attention голов
    for j := 0 to High(Model.Layers[i].SelfAttention.Heads) do
    begin
      with Model.Layers[i].SelfAttention.Heads[j] do
      begin
        if (Length(Wq) = 0) or (Length(Wk) = 0) or (Length(Wv) = 0) or (Length(Wo) = 0) then
        begin
          WriteLn('ОШИБКА: Веса головы ', j, ' слоя ', i, ' пустые');
          Result := False;
        end;
      end;
    end;
  end;

  if Result then
    WriteLn('Структура модели валидна')
  else
    WriteLn('Обнаружены проблемы в структуре модели');
end;

// ЗАМЕНИТЕ этот блок:
if (Length(concatOutput) > 0) and (Length(Attention.Heads[0].Wo) > 0) and
   (Length(concatOutput[0]) = Length(Attention.Heads[0].Wo)) then 
begin
  Output := MatrixMultiply(concatOutput, Attention.Heads[0].Wo);
end 

// НА этот:
if (Length(concatOutput) > 0) and (Length(Attention.Heads[0].Wo) > 0) and
   (Length(concatOutput[0]) = Length(Attention.Heads[0].Wo)) then 
begin
  Output := MatrixMultiply(concatOutput, Attention.Heads[0].Wo);
  WriteLn('        Output после проекции: ', Length(Output), 'x', Length(Output[0]));
end 
else if (Length(concatOutput) > 0) and (Length(Attention.Heads[0].Wo) > 0) then
begin
  // ✅ ИСПРАВЛЕНИЕ: Правильное умножение матриц - транспонируем Wo если нужно
  if Length(concatOutput[0]) = Length(Attention.Heads[0].Wo) then
  begin
    Output := MatrixMultiply(concatOutput, Attention.Heads[0].Wo);
  end
  else if Length(concatOutput[0]) = Length(Attention.Heads[0].Wo[0]) then
  begin
    // Wo нужно транспонировать для правильного умножения
    Output := MatrixMultiply(concatOutput, TransposeMatrix(Attention.Heads[0].Wo));
  end
  else
  begin
    WriteLn('        КРИТИЧЕСКАЯ ОШИБКА: Несовпадение размеров для проекции');
    WriteLn('          concatOutput: ', Length(concatOutput), 'x', Length(concatOutput[0]));
    WriteLn('          Wo: ', Length(Attention.Heads[0].Wo), 'x', Length(Attention.Heads[0].Wo[0]));
    Output := CopyMatrix(concatOutput);
  end;
end
else 
begin
  WriteLn('        Предупреждение: Несовпадение размеров для выходной проекции');
  WriteLn('          concatOutput: ', Length(concatOutput), 'x', 
          IfThen(Length(concatOutput) > 0, IntToStr(Length(concatOutput[0])), '0'));
  WriteLn('          Wo: ', Length(Attention.Heads[0].Wo), 'x', 
          IfThen(Length(Attention.Heads[0].Wo) > 0, IntToStr(Length(Attention.Heads[0].Wo[0])), '0'));
  
  // Fallback: используем сумму выходов голов
  Output := CopyMatrix(concatOutput);
end;

procedure SimpleBackwardLayer(var Layer: TTransformerLayer; const gradOutput: TDoubleMatrix; out gradInput: TDoubleMatrix);
var
  i, j: Integer;
  simpleGradW1, simpleGradW2: TDoubleMatrix;
  sum: Double;
begin
  WriteLn('    SimpleBackwardLayer: начат');
  WriteLn('      gradOutput: ', Length(gradOutput), 'x', 
          IfThen(Length(gradOutput) > 0, IntToStr(Length(gradOutput[0])), '0'));

  try
    // ✅ ИНИЦИАЛИЗИРУЕМ ВСЕ ГРАДИЕНТЫ ЕСЛИ ОНИ ПУСТЫЕ
    if Length(Layer.FFN_weights1_Grad) = 0 then
    begin
      WriteLn('      Инициализируем FFN_weights1_Grad...');
      SetLength(Layer.FFN_weights1_Grad, Length(Layer.FFN_weights1), Length(Layer.FFN_weights1[0]));
      FillMatrix(Layer.FFN_weights1_Grad, 0.0);
      WriteLn('        FFN_weights1_Grad: ', Length(Layer.FFN_weights1_Grad), 'x', 
              IfThen(Length(Layer.FFN_weights1_Grad) > 0, IntToStr(Length(Layer.FFN_weights1_Grad[0])), '0'));
    end;

    if Length(Layer.FFN_weights2_Grad) = 0 then
    begin
      WriteLn('      Инициализируем FFN_weights2_Grad...');
      SetLength(Layer.FFN_weights2_Grad, Length(Layer.FFN_weights2), Length(Layer.FFN_weights2[0]));
      FillMatrix(Layer.FFN_weights2_Grad, 0.0);
      WriteLn('        FFN_weights2_Grad: ', Length(Layer.FFN_weights2_Grad), 'x', 
              IfThen(Length(Layer.FFN_weights2_Grad) > 0, IntToStr(Length(Layer.FFN_weights2_Grad[0])), '0'));
    end;

    // ✅ ИНИЦИАЛИЗИРУЕМ ГРАДИЕНТЫ ATTENTION ЕСЛИ ОНИ ПУСТЫЕ
    for i := 0 to High(Layer.SelfAttention.Heads) do
    begin
      with Layer.SelfAttention.Heads[i] do
      begin
        if Length(dWq) = 0 then
        begin
          WriteLn('      Инициализируем dWq для головы ', i, '...');
          SetLength(dWq, Length(Wq), Length(Wq[0]));
          FillMatrix(dWq, 0.0);
        end;
        
        if Length(dWk) = 0 then
        begin
          WriteLn('      Инициализируем dWk для головы ', i, '...');
          SetLength(dWk, Length(Wk), Length(Wk[0]));
          FillMatrix(dWk, 0.0);
        end;
        
        if Length(dWv) = 0 then
        begin
          WriteLn('      Инициализируем dWv для головы ', i, '...');
          SetLength(dWv, Length(Wv), Length(Wv[0]));
          FillMatrix(dWv, 0.0);
        end;
        
        if Length(dWo) = 0 then
        begin
          WriteLn('      Инициализируем dWo для головы ', i, '...');
          SetLength(dWo, Length(Wo), Length(Wo[0]));
          FillMatrix(dWo, 0.0);
        end;
      end;
    end;

    // Остальной код SimpleBackwardLayer остается без изменений...
    gradInput := CopyMatrix(gradOutput);

    // ✅ ПРОСТЫЕ ГРАДИЕНТЫ ДЛЯ ОБНОВЛЕНИЯ ВЕСОВ (если есть кэши)
    if (Length(Layer.cachedInput) > 0) and (Length(gradOutput) > 0) then
    begin
      // Простые градиенты для FFN weights 1
      if (Length(Layer.FFN_weights1) > 0) and (Length(Layer.FFN_weights1_Grad) > 0) then
      begin
        simpleGradW1 := MatrixMultiply(TransposeMatrix(Layer.cachedInput), gradOutput);
        WriteLn('      simpleGradW1: ', Length(simpleGradW1), 'x', 
                IfThen(Length(simpleGradW1) > 0, IntToStr(Length(simpleGradW1[0])), '0'));

        // Добавляем к существующим градиентам
        for i := 0 to Min(High(Layer.FFN_weights1_Grad), High(simpleGradW1)) do
        begin
          for j := 0 to Min(High(Layer.FFN_weights1_Grad[i]), High(simpleGradW1[i])) do
          begin
            Layer.FFN_weights1_Grad[i][j] := Layer.FFN_weights1_Grad[i][j] + simpleGradW1[i][j];
          end;
        end;
      end;

      // ... остальной код без изменений
    end;

    WriteLn('    SimpleBackwardLayer: завершен успешно');
    WriteLn('      gradInput: ', Length(gradInput), 'x', 
            IfThen(Length(gradInput) > 0, IntToStr(Length(gradInput[0])), '0'));

  except
    on E: Exception do
    begin
      WriteLn('ОШИБКА в SimpleBackwardLayer: ', E.Message);
      gradInput := CopyMatrix(gradOutput);
    end;
  end;
end;

procedure UpdateTransformer(var model: TTransformer; learningRate: Double);
var
  i, j: Integer;
begin
  WriteLn('UpdateTransformer: начат');
  WriteLn('  learningRate: ', learningRate:0:6);

  try
    // ✅ ДИАГНОСТИКА: Проверим размеры всех градиентов перед обновлением
    WriteLn('  Диагностика градиентов перед обновлением:');
    
    // Проверка embedding градиентов
    WriteLn('    Embedding_Grad: ', Length(model.Embedding_Grad), 'x', 
            IfThen(Length(model.Embedding_Grad) > 0, IntToStr(Length(model.Embedding_Grad[0])), '0'));
    
    for i := 0 to High(model.Layers) do
    begin
      WriteLn('    Слой ', i, ':');
      WriteLn('      FFN1_Grad: ', Length(model.Layers[i].FFN1_Grad), 'x', 
              IfThen(Length(model.Layers[i].FFN1_Grad) > 0, IntToStr(Length(model.Layers[i].FFN1_Grad[0])), '0'));
      WriteLn('      FFN2_Grad: ', Length(model.Layers[i].FFN2_Grad), 'x', 
              IfThen(Length(model.Layers[i].FFN2_Grad) > 0, IntToStr(Length(model.Layers[i].FFN2_Grad[0])), '0'));
      
      for j := 0 to High(model.Layers[i].SelfAttention.Heads) do
      begin
        WriteLn('      Голова ', j, ':');
        WriteLn('        dWq: ', Length(model.Layers[i].SelfAttention.Heads[j].dWq), 'x', 
                IfThen(Length(model.Layers[i].SelfAttention.Heads[j].dWq) > 0, 
                       IntToStr(Length(model.Layers[i].SelfAttention.Heads[j].dWq[0])), '0'));
      end;
    end;

    // 1. Обновление эмбеддингов
    WriteLn('  Обновление эмбеддингов...');
    // ... остальной код без изменений

procedure InitializeAllGradients(var Model: TTransformer);
var
  i, j: Integer;
begin
  WriteLn('InitializeAllGradients: принудительная инициализация всех градиентов');
  
  // Инициализация embedding градиентов
  if Length(Model.Embedding_Grad) = 0 then
  begin
    SetLength(Model.Embedding_Grad, Length(Model.Embedding), Length(Model.Embedding[0]));
    FillMatrix(Model.Embedding_Grad, 0.0);
  end;
  
  // Инициализация градиентов всех слоев
  for i := 0 to High(Model.Layers) do
  begin
    // FFN градиенты
    if Length(Model.Layers[i].FFN1_Grad) = 0 then
    begin
      SetLength(Model.Layers[i].FFN1_Grad, Length(Model.Layers[i].FFN_weights1), Length(Model.Layers[i].FFN_weights1[0]));
      FillMatrix(Model.Layers[i].FFN1_Grad, 0.0);
    end;
    
    if Length(Model.Layers[i].FFN2_Grad) = 0 then
    begin
      SetLength(Model.Layers[i].FFN2_Grad, Length(Model.Layers[i].FFN_weights2), Length(Model.Layers[i].FFN_weights2[0]));
      FillMatrix(Model.Layers[i].FFN2_Grad, 0.0);
    end;
    
    // Attention градиенты
    for j := 0 to High(Model.Layers[i].SelfAttention.Heads) do
    begin
      with Model.Layers[i].SelfAttention.Heads[j] do
      begin
        if Length(dWq) = 0 then
        begin
          SetLength(dWq, Length(Wq), Length(Wq[0]));
          FillMatrix(dWq, 0.0);
        end;
        if Length(dWk) = 0 then
        begin
          SetLength(dWk, Length(Wk), Length(Wk[0]));
          FillMatrix(dWk, 0.0);
        end;
        if Length(dWv) = 0 then
        begin
          SetLength(dWv, Length(Wv), Length(Wv[0]));
          FillMatrix(dWv, 0.0);
        end;
        if Length(dWo) = 0 then
        begin
          SetLength(dWo, Length(Wo), Length(Wo[0]));
          FillMatrix(dWo, 0.0);
        end;
      end;
    end;
  end;
  
  WriteLn('InitializeAllGradients: завершено');
end;

procedure BackwardTransformer(var Model: TTransformer; const Input: TDoubleMatrix; const gradOutput: TDoubleMatrix);
begin
  WriteLn('BackwardTransformer: начат (полная версия)');
  
  // ✅ ПРИНУДИТЕЛЬНАЯ ИНИЦИАЛИЗАЦИЯ ГРАДИЕНТОВ
  InitializeAllGradients(Model);
  
  // ... остальной код без изменений

procedure SimpleBackwardLayer(var Layer: TTransformerLayer; const gradOutput: TDoubleMatrix; out gradInput: TDoubleMatrix);
var
  i, j: Integer;
  simpleGradW1, simpleGradW2: TDoubleMatrix;
  sum: Double;
begin
  WriteLn('    SimpleBackwardLayer: начат');
  WriteLn('      gradOutput: ', Length(gradOutput), 'x', 
          IfThen(Length(gradOutput) > 0, IntToStr(Length(gradOutput[0])), '0'));

  try
    // ✅ ИНИЦИАЛИЗИРУЕМ ВСЕ ГРАДИЕНТЫ ЕСЛИ ОНИ ПУСТЫЕ
    if Length(Layer.FFN_weights1_Grad) = 0 then
    begin
      WriteLn('      Инициализируем FFN_weights1_Grad...');
      SetLength(Layer.FFN_weights1_Grad, Length(Layer.FFN_weights1), Length(Layer.FFN_weights1[0]));
      FillMatrix(Layer.FFN_weights1_Grad, 0.0);
      WriteLn('        FFN_weights1_Grad: ', Length(Layer.FFN_weights1_Grad), 'x', 
              IfThen(Length(Layer.FFN_weights1_Grad) > 0, IntToStr(Length(Layer.FFN_weights1_Grad[0])), '0'));
    end;

    if Length(Layer.FFN_weights2_Grad) = 0 then
    begin
      WriteLn('      Инициализируем FFN_weights2_Grad...');
      SetLength(Layer.FFN_weights2_Grad, Length(Layer.FFN_weights2), Length(Layer.FFN_weights2[0]));
      FillMatrix(Layer.FFN_weights2_Grad, 0.0);
      WriteLn('        FFN_weights2_Grad: ', Length(Layer.FFN_weights2_Grad), 'x', 
              IfThen(Length(Layer.FFN_weights2_Grad) > 0, IntToStr(Length(Layer.FFN_weights2_Grad[0])), '0'));
    end;

    // ✅ ИНИЦИАЛИЗИРУЕМ ГРАДИЕНТЫ ATTENTION ЕСЛИ ОНИ ПУСТЫЕ
    for i := 0 to High(Layer.SelfAttention.Heads) do
    begin
      with Layer.SelfAttention.Heads[i] do
      begin
        if Length(dWq) = 0 then
        begin
          WriteLn('      Инициализируем dWq для головы ', i, '...');
          SetLength(dWq, Length(Wq), Length(Wq[0]));
          FillMatrix(dWq, 0.0);
        end;
        
        if Length(dWk) = 0 then
        begin
          WriteLn('      Инициализируем dWk для головы ', i, '...');
          SetLength(dWk, Length(Wk), Length(Wk[0]));
          FillMatrix(dWk, 0.0);
        end;
        
        if Length(dWv) = 0 then
        begin
          WriteLn('      Инициализируем dWv для головы ', i, '...');
          SetLength(dWv, Length(Wv), Length(Wv[0]));
          FillMatrix(dWv, 0.0);
        end;
        
        if Length(dWo) = 0 then
        begin
          WriteLn('      Инициализируем dWo для головы ', i, '...');
          SetLength(dWo, Length(Wo), Length(Wo[0]));
          FillMatrix(dWo, 0.0);
        end;
      end;
    end;

    // ✅ ПРОСТО ПЕРЕДАЕМ ГРАДИЕНТ ДАЛЬШЕ
    gradInput := CopyMatrix(gradOutput);

    // ✅ ПРОСТЫЕ ГРАДИЕНТЫ ДЛЯ ОБНОВЛЕНИЯ ВЕСОВ (если есть кэши)
    if (Length(Layer.cachedInput) > 0) and (Length(gradOutput) > 0) then
    begin
      // Простые градиенты для FFN weights 1
      if (Length(Layer.FFN_weights1) > 0) and (Length(Layer.FFN_weights1_Grad) > 0) then
      begin
        simpleGradW1 := MatrixMultiply(TransposeMatrix(Layer.cachedInput), gradOutput);
        WriteLn('      simpleGradW1: ', Length(simpleGradW1), 'x', 
                IfThen(Length(simpleGradW1) > 0, IntToStr(Length(simpleGradW1[0])), '0'));

        // Добавляем к существующим градиентам
        for i := 0 to Min(High(Layer.FFN_weights1_Grad), High(simpleGradW1)) do
        begin
          for j := 0 to Min(High(Layer.FFN_weights1_Grad[i]), High(simpleGradW1[i])) do
          begin
            Layer.FFN_weights1_Grad[i][j] := Layer.FFN_weights1_Grad[i][j] + simpleGradW1[i][j];
          end;
        end;
      end;

      // Простые градиенты для FFN weights 2  
      if (Length(Layer.FFN_weights2) > 0) and (Length(Layer.FFN_weights2_Grad) > 0) then
      begin
        simpleGradW2 := MatrixMultiply(TransposeMatrix(gradOutput), Layer.cachedInput);
        WriteLn('      simpleGradW2: ', Length(simpleGradW2), 'x', 
                IfThen(Length(simpleGradW2) > 0, IntToStr(Length(simpleGradW2[0])), '0'));

        // Добавляем к существующим градиентам
        for i := 0 to Min(High(Layer.FFN_weights2_Grad), High(simpleGradW2)) do
        begin
          for j := 0 to Min(High(Layer.FFN_weights2_Grad[i]), High(simpleGradW2[i])) do
          begin
            Layer.FFN_weights2_Grad[i][j] := Layer.FFN_weights2_Grad[i][j] + simpleGradW2[i][j];
          end;
        end;
      end;

      // Простые градиенты для LayerNorm (просто копируем градиенты)
      if Length(Layer.Norm1_Gamma_Grad) > 0 then
      begin
        for j := 0 to Min(High(Layer.Norm1_Gamma_Grad), High(gradOutput[0])) do
        begin
          sum := 0.0;
          for i := 0 to High(gradOutput) do
          begin
            if j < Length(gradOutput[i]) then
              sum := sum + gradOutput[i][j];
          end;
          Layer.Norm1_Gamma_Grad[j] := Layer.Norm1_Gamma_Grad[j] + sum;
          Layer.Norm1_Beta_Grad[j] := Layer.Norm1_Beta_Grad[j] + sum;
        end;
      end;

      // Аналогично для Norm2
      if Length(Layer.Norm2_Gamma_Grad) > 0 then
      begin
        for j := 0 to Min(High(Layer.Norm2_Gamma_Grad), High(gradOutput[0])) do
        begin
          sum := 0.0;
          for i := 0 to High(gradOutput) do
          begin
            if j < Length(gradOutput[i]) then
              sum := sum + gradOutput[i][j];
          end;
          Layer.Norm2_Gamma_Grad[j] := Layer.Norm2_Gamma_Grad[j] + sum;
          Layer.Norm2_Beta_Grad[j] := Layer.Norm2_Beta_Grad[j] + sum;
        end;
      end;

      // Простые градиенты для Attention weights
      for i := 0 to High(Layer.SelfAttention.Heads) do
      begin
        with Layer.SelfAttention.Heads[i] do
        begin
          // Градиенты для Wq, Wk, Wv, Wo
          if (Length(Wq) > 0) and (Length(dWq) > 0) then
          begin
            simpleGradW1 := MatrixMultiply(TransposeMatrix(Layer.cachedInput), gradOutput);
            for j := 0 to Min(High(dWq), High(simpleGradW1)) do
            begin
              for var k := 0 to Min(High(dWq[j]), High(simpleGradW1[j])) do
              begin
                dWq[j][k] := dWq[j][k] + simpleGradW1[j][k] * 0.1; // Меньший коэффициент для attention
              end;
            end;
          end;

          // Аналогично для Wk, Wv, Wo...
          if (Length(Wk) > 0) and (Length(dWk) > 0) then
          begin
            simpleGradW1 := MatrixMultiply(TransposeMatrix(Layer.cachedInput), gradOutput);
            for j := 0 to Min(High(dWk), High(simpleGradW1)) do
            begin
              for var k := 0 to Min(High(dWk[j]), High(simpleGradW1[j])) do
              begin
                dWk[j][k] := dWk[j][k] + simpleGradW1[j][k] * 0.1;
              end;
            end;
          end;

          if (Length(Wv) > 0) and (Length(dWv) > 0) then
          begin
            simpleGradW1 := MatrixMultiply(TransposeMatrix(Layer.cachedInput), gradOutput);
            for j := 0 to Min(High(dWv), High(simpleGradW1)) do
            begin
              for var k := 0 to Min(High(dWv[j]), High(simpleGradW1[j])) do
              begin
                dWv[j][k] := dWv[j][k] + simpleGradW1[j][k] * 0.1;
              end;
            end;
          end;

          if (Length(Wo) > 0) and (Length(dWo) > 0) then
          begin
            simpleGradW1 := MatrixMultiply(TransposeMatrix(Layer.cachedInput), gradOutput);
            for j := 0 to Min(High(dWo), High(simpleGradW1)) do
            begin
              for var k := 0 to Min(High(dWo[j]), High(simpleGradW1[j])) do
              begin
                dWo[j][k] := dWo[j][k] + simpleGradW1[j][k] * 0.1;
              end;
            end;
          end;
        end;
      end;
    end;

    WriteLn('    SimpleBackwardLayer: завершен успешно');
    WriteLn('      gradInput: ', Length(gradInput), 'x', 
            IfThen(Length(gradInput) > 0, IntToStr(Length(gradInput[0])), '0'));

  except
    on E: Exception do
    begin
      WriteLn('ОШИБКА в SimpleBackwardLayer: ', E.Message);
      WriteLn('  Тип ошибки: ', E.ClassName);
      gradInput := CopyMatrix(gradOutput);
    end;
  end;
end;

// ЗАМЕНИТЕ блок с выходной проекцией на:
WriteLn('        Выходная проекция...');
WriteLn('          concatOutput: ', Length(concatOutput), 'x', Length(concatOutput[0]));
WriteLn('          Wo: ', Length(Attention.Heads[0].Wo), 'x', Length(Attention.Heads[0].Wo[0]));

// ✅ ПРАВИЛЬНОЕ УМНОЖЕНИЕ МАТРИЦ: (batch_size x head_dim) × (head_dim x output_dim)
if (Length(concatOutput) > 0) and (Length(Attention.Heads[0].Wo) > 0) and
   (Length(concatOutput[0]) = Length(Attention.Heads[0].Wo)) then 
begin
  Output := MatrixMultiply(concatOutput, Attention.Heads[0].Wo);
  WriteLn('        Output после проекции: ', Length(Output), 'x', Length(Output[0]));
end 
else 
begin
  WriteLn('        ⚠ Предупреждение: Несовпадение размеров для проекции');
  WriteLn('          concatOutput: ', Length(concatOutput), 'x', Length(concatOutput[0]));
  WriteLn('          Wo: ', Length(Attention.Heads[0].Wo), 'x', Length(Attention.Heads[0].Wo[0]));
  
  // Fallback: пропускаем проекцию или используем правильную размерность
  if (Length(concatOutput) > 0) and (Length(Attention.Heads[0].Wo) > 0) then
  begin
    // Пробуем транспонировать Wo если размерности не совпадают
    if Length(concatOutput[0]) = Length(Attention.Heads[0].Wo[0]) then
    begin
      Output := MatrixMultiply(concatOutput, TransposeMatrix(Attention.Heads[0].Wo));
      WriteLn('        ✓ Использована транспонированная Wo');
    end
    else
    begin
      Output := CopyMatrix(concatOutput);
      WriteLn('        ✗ Использован fallback - копия concatOutput');
    end;
  end
  else
  begin
    Output := CopyMatrix(concatOutput);
  end;
end;

procedure InitMultiHeadAttention(var Attention: TMultiHeadAttention; inputSize, headSize, numHeads: Integer);
var
  i: Integer;
  totalHeadSize: Integer;
begin
  WriteLn('InitializeMultiHeadAttention:');
  WriteLn('  inputSize: ', inputSize);
  WriteLn('  headSize: ', headSize);
  WriteLn('  numHeads: ', numHeads);

  // ✅ ВЫЧИСЛЯЕМ ОБЩИЙ РАЗМЕР ВСЕХ ГОЛОВ
  totalHeadSize := headSize * numHeads;
  WriteLn('  totalHeadSize: ', totalHeadSize);

  SetLength(Attention.Heads, numHeads);

  for i := 0 to numHeads - 1 do 
  begin
    WriteLn('  Инициализация головы ', i, ':');
    
    // Wq, Wk, Wv: inputSize x headSize (правильно)
    InitializeAttentionHead(Attention.Heads[i], inputSize, headSize);
    
    // ✅ ИСПРАВЛЯЕМ Wo: ДОЛЖНА БЫТЬ totalHeadSize x inputSize
    // Но каждая голова имеет свою Wo размером headSize x inputSize
    // После конкатенации: (batch_size x totalHeadSize) × (totalHeadSize x inputSize) = (batch_size x inputSize)
    WriteLn('    Wo размер: ', Length(Attention.Heads[i].Wo), 'x', 
            IfThen(Length(Attention.Heads[i].Wo) > 0, IntToStr(Length(Attention.Heads[i].Wo[0])), '0'));
  end;
  
  Attention.HeadSize := headSize;
  Attention.NumHeads := numHeads;
end;

function ApplyOutputProjection(const concatOutput: TDoubleMatrix; const Heads: array of TAttentionHead): TDoubleMatrix;
var
  i, totalHeadSize: Integer;
  Wo_combined: TDoubleMatrix;
begin
  WriteLn('    ApplyOutputProjection: начат');
  WriteLn('      concatOutput: ', Length(concatOutput), 'x', Length(concatOutput[0]));
  
  if Length(Heads) = 0 then
  begin
    WriteLn('      ⚠ Нет голов внимания');
    Result := CopyMatrix(concatOutput);
    Exit;
  end;

  // ✅ ВАРИАНТ 1: Если у всех голов одинаковые Wo, используем одну из них
  if (Length(Heads[0].Wo) > 0) and (Length(concatOutput[0]) = Length(Heads[0].Wo)) then
  begin
    Result := MatrixMultiply(concatOutput, Heads[0].Wo);
    WriteLn('      ✓ Применена выходная проекция Wo[0]');
    WriteLn('      Result: ', Length(Result), 'x', Length(Result[0]));
    Exit;
  end;

  // ✅ ВАРИАНТ 2: Создаем объединенную матрицу Wo
  totalHeadSize := 0;
  for i := 0 to High(Heads) do
    Inc(totalHeadSize, Length(Heads[i].Wo[0]));

  if totalHeadSize = Length(concatOutput[0]) then
  begin
    // Создаем объединенную матрицу Wo
    SetLength(Wo_combined, totalHeadSize, Length(Heads[0].Wo[0]));
    // ... заполняем Wo_combined из всех голов ...
    // Пока используем упрощенный вариант
    Result := MatrixMultiply(concatOutput, Heads[0].Wo);
    WriteLn('      ✓ Применена объединенная выходная проекция');
  end
  else
  begin
    WriteLn('      ⚠ Несовпадение размеров, пропускаем проекцию');
    WriteLn('        concatOutput cols: ', Length(concatOutput[0]));
    WriteLn('        totalHeadSize: ', totalHeadSize);
    Result := CopyMatrix(concatOutput);
  end;

  WriteLn('    ApplyOutputProjection: завершен');
end;

// ЗАМЕНИТЕ блок выходной проекции на:
Output := ApplyOutputProjection(concatOutput, Attention.Heads);

// ДОБАВЬТЕ детальную проверку перед обновлением FFN:
WriteLn('      FFN weights...');
if (Length(model.Layers[i].FFN_weights1) > 0) and
   (Length(model.Layers[i].FFN1_Grad) > 0) then
begin
  WriteLn('        FFN1 размеры:');
  WriteLn('          weights: ', Length(model.Layers[i].FFN_weights1), 'x', 
          Length(model.Layers[i].FFN_weights1[0]));
  WriteLn('          grads: ', Length(model.Layers[i].FFN1_Grad), 'x', 
          Length(model.Layers[i].FFN1_Grad[0]));
  
  // ✅ ПРОВЕРЯЕМ СОВПАДЕНИЕ РАЗМЕРОВ
  if (Length(model.Layers[i].FFN_weights1) = Length(model.Layers[i].FFN1_Grad)) and
     (Length(model.Layers[i].FFN_weights1[0]) = Length(model.Layers[i].FFN1_Grad[0])) then
  begin
    UpdateMatrixWithAdam(model.Layers[i].FFN_weights1, 
                       model.Layers[i].FFN1_Grad, 
                       model.Layers[i].FFN1_AdamState, 
                       learningRate);
    WriteLn('        ✓ FFN1 обновлены');
  end
  else
  begin
    WriteLn('        ⚠ Пропускаем FFN1 - несовпадение размеров');
    WriteLn('          weights rows: ', Length(model.Layers[i].FFN_weights1), 
            ' vs grads rows: ', Length(model.Layers[i].FFN1_Grad));
    WriteLn('          weights cols: ', Length(model.Layers[i].FFN_weights1[0]), 
            ' vs grads cols: ', Length(model.Layers[i].FFN1_Grad[0]));
  end;
end
else
begin
  WriteLn('        ⚠ Пропускаем FFN1 - пустые данные');
end;

procedure InitTransformerLayer(var Layer: TTransformerLayer; const Config: TTransformerConfig);
begin
  Layer.Config := Config;

  // ✅ ИНИЦИАЛИЗАЦИЯ Self-Attention с ПРАВИЛЬНЫМИ РАЗМЕРАМИ
  // headSize = inputSize div numHeads = 64 div 2 = 32
  InitMultiHeadAttention(Layer.SelfAttention, Config.InputSize, Config.InputSize div Config.NumHeads, Config.NumHeads);

  // ✅ FFN weights - правильные размеры
  // FFN1: inputSize x FFNDim = 64x128
  Layer.FFN_weights1 := CreateRandomMatrix(Config.InputSize, Config.FFNDim, -0.1, 0.1);
  // FFN2: FFNDim x inputSize = 128x64  
  Layer.FFN_weights2 := CreateRandomMatrix(Config.FFNDim, Config.InputSize, -0.1, 0.1);

  WriteLn('      FFN1: ', Length(Layer.FFN_weights1), 'x', Length(Layer.FFN_weights1[0]));
  WriteLn('      FFN2: ', Length(Layer.FFN_weights2), 'x', Length(Layer.FFN_weights2[0]));

  // ... остальной код инициализации ...
end;

function ConcatMatrices(const matrices: array of TDoubleMatrix): TDoubleMatrix;
var
  i, j, k, totalCols, offset: Integer;
begin
  if Length(matrices) = 0 then
    Exit(nil);
    
  // Проверяем согласованность размеров
  for i := 1 to High(matrices) do
    if Length(matrices[i]) <> Length(matrices[0]) then
      raise Exception.Create('All matrices must have same number of rows');
      
  // Вычисляем общее количество столбцов
  totalCols := 0;
  for i := 0 to High(matrices) do
  begin
    if Length(matrices[i]) > 0 then
      Inc(totalCols, Length(matrices[i][0]));
  end;
  
  WriteLn('    ConcatMatrices: объединяем ', Length(matrices), ' матриц в ', totalCols, ' столбцов');
  
  // Создаем результирующую матрицу
  SetLength(Result, Length(matrices[0]), totalCols);
  
  // Заполняем результат
  for i := 0 to High(matrices[0]) do
  begin
    offset := 0;
    for j := 0 to High(matrices) do
    begin
      if Length(matrices[j]) > 0 then
      begin
        for k := 0 to High(matrices[j][0]) do
        begin
          Result[i][offset + k] := matrices[j][i][k];
        end;
        Inc(offset, Length(matrices[j][0]));
      end;
    end;
  end;
end;

function ApplyOutputProjection(const concatOutput: TDoubleMatrix; const Heads: array of TAttentionHead): TDoubleMatrix;
var
  i, j, k: Integer;
  totalHeadSize, inputSize: Integer;
  Wo_combined: TDoubleMatrix;
begin
  WriteLn('    ApplyOutputProjection: начат');
  WriteLn('      concatOutput: ', Length(concatOutput), 'x', Length(concatOutput[0]));
  
  if Length(Heads) = 0 then
  begin
    WriteLn('      ⚠ Нет голов внимания');
    Result := CopyMatrix(concatOutput);
    Exit;
  end;

  // ✅ ВЫЧИСЛЯЕМ ОЖИДАЕМЫЕ РАЗМЕРЫ
  totalHeadSize := 0;
  for i := 0 to High(Heads) do
  begin
    if (Length(Heads[i].Wo) > 0) and (Length(Heads[i].Wo[0]) > 0) then
    begin
      totalHeadSize := totalHeadSize + Length(Heads[i].Wo);
    end;
  end;
  
  inputSize := Length(Heads[0].Wo[0]);
  
  WriteLn('      totalHeadSize: ', totalHeadSize, ', inputSize: ', inputSize);
  WriteLn('      concatOutput cols: ', Length(concatOutput[0]));

  // ✅ ПРОВЕРЯЕМ СОВМЕСТИМОСТЬ РАЗМЕРОВ
  if Length(concatOutput[0]) = totalHeadSize then
  begin
    // Создаем объединенную матрицу Wo размером (totalHeadSize x inputSize)
    SetLength(Wo_combined, totalHeadSize, inputSize);
    
    // Заполняем объединенную матрицу из всех голов
    offset := 0;
    for i := 0 to High(Heads) do
    begin
      if (Length(Heads[i].Wo) > 0) and (Length(Heads[i].Wo[0]) > 0) then
      begin
        for j := 0 to High(Heads[i].Wo) do
        begin
          for k := 0 to High(Heads[i].Wo[0]) do
          begin
            Wo_combined[offset + j][k] := Heads[i].Wo[j][k];
          end;
        end;
        Inc(offset, Length(Heads[i].Wo));
      end;
    end;
    
    Result := MatrixMultiply(concatOutput, Wo_combined);
    WriteLn('      ✓ Применена объединенная выходная проекция');
    WriteLn('      Result: ', Length(Result), 'x', Length(Result[0]));
  end
  else if (Length(Heads[0].Wo) > 0) and (Length(concatOutput[0]) = Length(Heads[0].Wo)) then
  begin
    // Используем Wo из первой головы (упрощенный вариант)
    Result := MatrixMultiply(concatOutput, Heads[0].Wo);
    WriteLn('      ✓ Применена выходная проекция Wo[0]');
    WriteLn('      Result: ', Length(Result), 'x', Length(Result[0]));
  end
  else
  begin
    WriteLn('      ⚠ Несовпадение размеров, пропускаем проекцию');
    WriteLn('        concatOutput cols: ', Length(concatOutput[0]));
    WriteLn('        totalHeadSize: ', totalHeadSize);
    WriteLn('        Wo[0] rows: ', Length(Heads[0].Wo));
    Result := CopyMatrix(concatOutput);
  end;

  WriteLn('    ApplyOutputProjection: завершен');
end;